Data Generation Flowchart

The following flowchart, taken from the conference paper Nicolas and Sakib 2024, shows the process used for generating each observation in the dataset.

Data Generation Flowchart

Here we show the code used to generate a single observation which is one student. This was run 100,000 times to generate the dataset this work analyzes.

def generate_single_sample(self):
        """
        Generate a single sample of synthetic data.
        :return: Dictionary representing a single data sample.
        """
        try:
            first_name = random.choice(self.first_names)
            last_name = random.choice(self.last_names)
            ethnoracial_group = self.assign_demographic(self.ethnoracial_stats, self.ethnoracial_dist)
            gender = self.assign_demographic(self.gender_stats, self.gender_dist)
            international_status = self.assign_demographic(self.international_stats, self.international_dist)
            socioeconomic_status = self.assign_demographic(self.socioeconomic_stats, self.socioeconomic_dist)
            identities = [ethnoracial_group, gender, international_status]
            learning_style = self.generate_learning_style()
            student_semester = np.random.randint(0, 15)
            gpa = self.generate_gpa(student_semester)
            major = self.choose_major(student_semester, gender)
            extracurricular_activities = self.generate_identity_org(identities)

            previous_courses = []
            subjects = []
            career_aspirations_list = []

            # Iterate through each semester the student has been at the school.
            # Courses, subjects or interest, career aspirations and extracurriculars
            # all interact with one another.
            for semester in range(student_semester + 1):
                previous_courses = self.generate_previous_courses(semester, learning_style, previous_courses, major)
                num_courses = len(previous_courses)
                top_subject, class_count = self.most_common_class_subject(previous_courses)
                subjects = self.generate_subjects_of_interest(previous_courses, subjects, major, top_subject, career_aspirations_list)
                career_aspirations_list = self.generate_career_aspirations(career_aspirations_list, subjects, major, extracurricular_activities)
                extracurricular_activities = self.generate_extracurricular_activities(subjects, extracurricular_activities, major, career_aspirations_list)

                # If the student has been there for 4 or more semesters and has enough courses,
                # including those in their major then make them graduate by breaking the loop
                if semester >= 8 and num_courses >= 32 and class_count >= 8:
                    student_semester = semester
                    break

            if logging.getLogger().isEnabledFor(logging.DEBUG):
                logging.debug("Iterated through %s semesters", student_semester)

            # Split the tuples into course name, course type, and course subject
            # Ex: Intro Asian American Studies, Discussion/Recitation, AAS
            course_names = [course[0] for course in previous_courses]
            course_type = list(set([tuple(course[2]) for course in previous_courses]))
            course_subject = list(set([course[3] for course in previous_courses]))

            # Create weighted lists based on how often an element was in a list
            subjects, subject_weights = self.create_weighted_list(subjects)
            extracurricular_activities, activity_weights = self.create_weighted_list(extracurricular_activities)
            career_aspirations_list, career_weights = self.create_weighted_list(career_aspirations_list)

            # Majors are weighted by semester and gpa
            major_weights = [student_semester * gpa if student_semester != 0 else 0] * len(major)

            # Generate the future topics
            future_topics = self.generate_future_topics(subjects, subject_weights, extracurricular_activities, activity_weights, career_aspirations_list, career_weights, major, major_weights)

            # Create the new 'student'
            sample_data = {
                'first name': first_name,
                'last name': last_name,
                'ethnoracial group': ethnoracial_group,
                'gender': gender,
                'international status': international_status,
                'socioeconomic status': socioeconomic_status,
                'learning style': learning_style,
                'gpa': gpa,
                'student semester': student_semester,
                'major': major,
                'previous courses': course_names,
                'course types': course_type,
                'course subjects': course_subject,
                'subjects of interest': subjects,
                'extracurricular activities': extracurricular_activities,
                'career aspirations': career_aspirations_list,
                'future topics': future_topics
            }

            if logging.getLogger().isEnabledFor(logging.DEBUG):
                logging.debug("Single sample generated")
            return sample_data
        except Exception as e:
            logging.error(f"Error generating sample: {e}")
            return None

Motivating the Analysis

The work took this dataset and privatized it and then used machine learning to predict the privacy-utility tradeoff of the different privatization methods. However, the question of the accuracy of the original purely synthetic dataset remains. This work addresses this by running a variety of descriptive statistics on the dataset and comparing the results to both the algorithm that produced the dataset and the intended connections and distributions.

Working with Numerical Variables

The range of GPA and Student Semester are too large for correlations and comparisons. So here we make two new columns. One with GPA in intervals of 0.5 and one with Student Year.

dataset <- dataset |>
  # Count the number of observations with each value
  group_by(gpa) |>
  mutate(gpa_count = n()) |>
  ungroup() |>
  # Make the GPA tooltip text
  mutate(text_gpa = paste("GPA", ": ", gpa, "\nCount: ", gpa_count, sep="")) |>
  # Count the number of observations with each value
  group_by(student_semester) |>
  mutate(student_semester_count = n()) |>
  ungroup() |>
  # Make the Student Semester tooltip text
  mutate(text_student_semester = paste("Student Semester", ": ", student_semester, "\nCount: ", student_semester_count, sep=""))

Function Design

Before we begin the analysis, we design functions to reduce repetitiveness and length. The split_into_multiple function was inspired by stack exchange.

# This function makes correlation tables
correlation_table <- function(.data_1, .data_2) {
  SES_tab <- table(.data_1,.data_2)
  pilltabs(SES_tab)
}
 
# This function makes correlation graphs
correlation_graph <- function(x_name, y_name, flip = TRUE) {
  # Get the x and y columns based on the inputed name
  .x = dataset_col_names[x_name]
  .y = dataset_col_names[y_name]
    
  # Make the ggplot
  plot <- ggplot(dataset, aes_string(x = .x,
                    fill = .y)) +
  geom_bar(position = "fill") +
  theme_classic() +
  scale_fill_brewer(palette = "Dark2") +
  labs(x = x_name,
       y = "Proportion",
       fill = y_name)
  
  # Flip coordinates if flip is TRUE
  if (flip) {
    plot <- plot + coord_flip()
  }
  
  # Return the plot
  return(plot)
}

# This function splits the list columns
split_into_multiple <- function(column, into_prefix, pattern = "\', \'"){
  cols <- str_split_fixed(column, pattern, n = Inf)
  # Sub out the ""'s returned by filling the matrix to the right, with NAs which are useful
  cols[which(cols == "")] <- NA
  cols <- as.tibble(cols)

  # name the 'cols' tibble as 'into_prefix_1', 'into_prefix_2', ..., 'into_prefix_m' 
  # where m = # columns of 'cols'
  m <- dim(cols)[2]

  names(cols) <- paste(into_prefix, 1:m, sep = "_")
  
  # Convert the tibble to a dataframe
  cols <- as.data.frame(cols)
  
  # Remove remaining brackets and quotes
  for (i in 1:m) {
    cols[,i] <- str_remove_all(cols[,i], "[\'\\[\\]]")
  }
  
  return(cols)
}

# Convert split list columns into a single dataframe with demographic information
make_demographic_dataframe <- function(main_df, .columns, .name, dem_cols = c(3:6), rm.na = FALSE, .name_list = list()) {
  # Create an empty dataframe
  final_df = data.frame(ethnoracial_group=factor(),
                        gender = factor(),
                        international_status = factor(),
                        socioeconomic_status = factor())
  
  # Take each split list column and combine row wise
  for (i in .columns) {
    df <- main_df |>
      select(c(dem_cols,i))
    final_df <- rbind(final_df, setNames(df, colnames(final_df)))
  }

  # Add in extra names if more columns are added beyond the demographic ones
  
  if (length(.name_list) > 0) {
    for (i in 1:length(.name_list)) {
      colnames(final_df)[i+4] <- .name_list[i]
    }
  }
  
  # Ensure proper naming for the final column
  colnames(final_df)[5+length(.name_list)] <- .name
  
  # Drop the empty columns
  if (rm.na) {
    final_df <- final_df |>
      drop_na()
  }
  
  return(final_df)
}

# Makes Graphs for the different numerical columns whose data
# was generated from a uniform distribution
numerical_col_graph <- function(.dataset, .column, .name, .text, .size) {
  
  # Get the dataset size
  row_len_df <- .dataset |>
    drop_na({{.column}})
  
  row_len <- nrow(row_len_df)

  # Make the ggplot graph with a line for the uniform distribution
  graph <- .dataset |>
    
    # Make the ggplot
    ggplot(aes(x = {{.column}}, text = {{.text}})) +
    geom_bar(fill = "gray") +
    theme_ipsum() +
    labs(x = .name, y = "Number of Students") +
    geom_hline(yintercept = row_len/.size) +
    theme(legend.position="none")
  
  # Make the plotly
  ggplotly(graph, tooltip = "text")
}

# Generate a graph of the top ten majors with the highest majority of a certain
# gender identity
major_gender_dominated_graph <- function(.dataset, .gender, .xlab, .ylab) {
  # Arrange major by top percent gender minority
  g_dominate_dataset <- .dataset |>
    arrange(desc({{.gender}}))
  
  # Get a graph of the top ten majors
  ggplot(g_dominate_dataset[1:10,],
         aes(x=reorder(major, {{.gender}}, FUN = function(x) sum(x)),
             y={{.gender}},
             fill = division)) +
    geom_bar(stat = "identity") +
    coord_flip() +
    theme_classic() +
    scale_color_brewer(palette = "Dark2") +
    labs(x = .xlab,
         y = .ylab,
         fill = "Major Division")

}

chisq_df_generation <- function(demographic_df, .column, expected_percent) {
  
  # Count the number of students with each learning style
  counts_df <- demographic_df |>
    group_by({{.column}}) |>
    drop_na() |>
    summarize(count = n()) |>
    ungroup()
  
  # Combine the expected results with the counts Dataset
  counts_df <- counts_df |>
    mutate(observed_percent = count / nrow(demographic_df)) |>
    cbind(expected_percent) |>
    mutate(expected_percent = expected_percent / 100)
  
  return(counts_df)
}

Spliting the Lists

Now we will use our split_into_multiple function to split up the list features that we will use in this work.

dataset_split <- dataset |>
  # Learning Style
  cbind(split_into_multiple(dataset$learning_style, "learning_style")) |>
  mutate(learning_style = NULL) |>
  mutate(learning_style_1 = as.factor(learning_style_1)) |>
  mutate(learning_style_2 = as.factor(learning_style_2)) |>
  # Major
  cbind(split_into_multiple(dataset$major, "major")) |>
  mutate(major = NULL) |>
  # Previous Course Types
  cbind(split_into_multiple(dataset$course_types, "course_types")) |>
  mutate(course_types = NULL) |>
  # Previous Course Subjects
  cbind(split_into_multiple(dataset$course_subjects, "course_subjects")) |>
  mutate(course_subjects = NULL)

Conclusion

We found that none of the different demographics had any correlations. This result was expected as all the demographics were sampled from separate distributions. The result confirms that this dataset should not be used for research on college student intersectionality.

Most Popular Majors

First, we look across majors and pull out the demographic data. Here we list out the top 10 most popular majors. Data from the majors dataset was webscrapped and and slightly altered from this website Economics (2024). The jsonlite package Ooms (2014) is used to import this data.

# Bring in the Majors Dataset which contains real world statistics

majors_data <- fromJSON("majors.json", flatten = TRUE)

# Rename the columns and convert the strings to numerical values and factors

majors_data <- as.data.frame(majors_data) |>
  rename(major = V1) |>
  rename(national_percent_female = V2) |>
  mutate(national_percent_female = as.numeric(national_percent_female) / 100) |>
  # Divide by 100 since the values are between 1 and 100 not 0 and 1
  rename(national_popularity_ranking = V3) |>
  mutate(national_popularity_ranking = as.numeric(national_popularity_ranking)) |>
  rename(division = V4) |>
  mutate(division = as.factor(division)) |>
  rename(top_5_careers = V5) |>
  mutate(top_5_careers = str_remove_all(top_5_careers, "[\'\\[\\]]"))

# Make the Major Demographics Dataset and join it to the Majors Data dataset
majors_demographics <- make_demographic_dataframe(dataset_split, c("major_1", "major_2"), "major", rm.na = TRUE) |>
  group_by(major) |>
  mutate(major = case_when(major == "" ~ NA, .default = major)) |>
  ungroup()

# Create the Major Counts Dataset

major_counts <- majors_demographics |>
  group_by(major) |>
  drop_na() |>
  summarize(major_count = n()) |>
  ungroup()

# Add in the Majors Data to the Majors Counts Dataset

major_counts <- major_counts |>
  left_join(majors_data, by = join_by(major)) |>
  arrange(desc(major_count))

# Add in the observed popularity rankings to the Major Counts Dataset

popularity_ranking <- c(1:length(major_counts$major))

major_counts <- cbind(major_counts, popularity_ranking)

# Join Major Counts to Majors Demographics

majors_demographics <- majors_demographics |>
  left_join(major_counts, by = join_by(major)) |>
  arrange(desc(major_count))

# Plot the Top 10 Majors

ggplot(major_counts[1:10,], aes(x = reorder(major, major_count, FUN = function(x) sum(x)),
                                y = major_count,
                                fill = division)) +
  coord_flip() +
  theme_classic() +
  scale_fill_viridis(discrete=TRUE) +
  geom_bar(stat = "identity") +
  labs(x = "Size of Major",
       y = "Most Popular Majors",
       fill = "Major Division")

The popularity ranking of a major impacts the major choice in the major function. Thus we will compare our expected and observed major popularity rankings to see if this aspect of the major function worked as intended. Now we run a Chi Squared Goodness of Fit Test comparing the observed major popularity rankings and expected major popularity rankings.

# Chi Squared Goodness of Fit Test
observed_major_rankings <- major_counts[,7]
expected_major_rankings <- major_counts[,4]

chisq.test(x = observed_major_rankings, p = expected_major_rankings / sum(expected_major_rankings))

## 
##  Chi-squared test for given probabilities
## 
## data:  observed_major_rankings
## X-squared = 480.7, df = 172, p-value < 2.2e-16

This graph shows each major and compares observed major popularity vs what was expected based on the national data.

p <- major_counts |>
  # Make tooltip text
    mutate(text = paste("Major: ", major, "\nNumber of Majors: ", major_count, "\nObserved Major Popularity Ranking: ", popularity_ranking, "\nNational Major Popularity Ranking: ", national_popularity_ranking, sep="")) |>
  
  ggplot(aes(x = popularity_ranking,
           y = national_popularity_ranking,
           color = division,
           text=text)) +
  geom_point() +
  theme_classic() +
  scale_color_viridis(discrete=TRUE, guide=FALSE) +
  labs(x = "Observed Major Popularity Ranking",
       y = "Expected Major Popularity Ranking",
       color = "Major Division")

# Make the plot interactive with ggplotly
ggplotly(p, tooltip="text")